Built with doc-gen4, running Lean4. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+โ†‘Ctrl+โ†“to navigate, Ctrl+๐Ÿ–ฑ๏ธto focus. On Mac, use Cmdinstead of Ctrl. 

import SSA.Core.WellTypedFramework
import SSA.Projects.InstCombine.InstCombineBase

open SSA InstCombine


-- Name:AddSub:1043
-- precondition: true
/-
  %Y = and %Z, C1
  %X = xor %Y, C1
  %LHS = add %X, 1
  %r = add %LHS, %RHS

=>
  %or = or %Z, ~C1
  %Y = and %Z, C1
  %X = xor %Y, C1
  %LHS = add %X, 1
  %r = sub %RHS, %or

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
Z: โ„•
Z 
C1: โ„•
C1 
RHS: โ„•
RHS 
Z: โ„•
Z 
C1: โ„•
C1 
RHS: โ„•
RHS : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.4052
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
Z: โ„•
Z)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
C1: โ„•
C1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v4 %v2;
  %v6 := op:xor 
w: โ„•
w %v5;
  %v7 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
1: ?m.5048
1)) %v9999;
  %v8 := pair:%v6 %v7;
  %v9 := op:add 
w: โ„•
w %v8;
  %v10 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
RHS: โ„•
RHS)) %v9999;
  %v11 := pair:%v9 %v10;
  %v12 := op:add 
w: โ„•
w %v11
  dsl_ret %v12
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.4052
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
Z: โ„•
Z)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
C1: โ„•
C1)) %v9999;
  %v3 := op:not 
w: โ„•
w %v2;
  %v4 := pair:%v1 %v3;
  %v5 := op:or 
w: โ„•
w %v4;
  %v6 := pair:%v1 %v2;
  %v7 := op:and 
w: โ„•
w %v6;
  %v8 := pair:%v7 %v2;
  %v9 := op:xor 
w: โ„•
w %v8;
  %v10 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
1: ?m.8840
1)) %v9999;
  %v11 := pair:%v9 %v10;
  %v12 := op:add 
w: โ„•
w %v11;
  %v13 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
RHS: โ„•
RHS)) %v9999;
  %v14 := pair:%v13 %v5;
  %v15 := op:sub 
w: โ„•
w %v14
  dsl_ret %v15
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (Z C1 RHS : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 11 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 10
                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘RHS))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 7
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 1))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.pair Context.Var.last
                                        (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1))
                                              (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Z)) Context.Var.last TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 15 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 14
                          (TSSA.pair Context.Var.last
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))) โˆ˜                       (fun prev =>
                          TSSA.assign prev 13
                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘RHS))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev
                                                  (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 12 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 11 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 10
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 1))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev
                                                  (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 8
                                      (TSSA.pair Context.Var.last
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                                   (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 6
                                          (TSSA.pair
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                                       (fun prev => TSSA.assign prev 5 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 4
                                              (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                                                Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 3 (TSSA.op (Op.not w) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 2
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1))
                                                    (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                               (fun prev =>
                                                  TSSA.assign prev 1
                                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Z)) Context.Var.last
                                                      TSSA.rgn0)) โˆ˜                                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

w, Z, C, RHS, Z', C1, RHS': โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 11 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 10
                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘RHS'))
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 9 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.op (Op.const (Bitvec.ofInt' w 1))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair Context.Var.last (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Z')) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 15 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 14
                (TSSA.pair Context.Var.last
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))) โˆ˜             (fun prev =>
                TSSA.assign prev 13
                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘RHS'))
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 12 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 11 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.op (Op.const (Bitvec.ofInt' w 1))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                          TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                             (fun prev => TSSA.assign prev 5 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 4
                                    (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                                      Context.Var.last)) โˆ˜                                 (fun prev => TSSA.assign prev 3 (TSSA.op (Op.not w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Z')) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (Z C1 RHS : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 11 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 10
                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘RHS))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 7
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 1))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.pair Context.Var.last
                                        (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1))
                                              (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Z)) Context.Var.last TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 15 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 14
                          (TSSA.pair Context.Var.last
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))) โˆ˜                       (fun prev =>
                          TSSA.assign prev 13
                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘RHS))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev
                                                  (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 12 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 11 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 10
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 1))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev
                                                  (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 8
                                      (TSSA.pair Context.Var.last
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                                   (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 6
                                          (TSSA.pair
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                                       (fun prev => TSSA.assign prev 5 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 4
                                              (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                                                Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 3 (TSSA.op (Op.not w) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 2
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1))
                                                    (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                               (fun prev =>
                                                  TSSA.assign prev 1
                                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Z)) Context.Var.last
                                                      TSSA.rgn0)) โˆ˜                                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

w, Z, C, RHS, Z', C1, RHS': โ„•

(do
    let x โ† some (Bitvec.ofInt' w โ†‘Z')
    let x_1 โ† some (Bitvec.ofInt' w โ†‘C1)
    let x_2 โ† some (Bitvec.ofInt' w โ†‘C1)
    let x_3 โ† some (Bitvec.ofInt' w 1)
    let fst โ† Bitvec.add? (Bitvec.xor (Bitvec.and x x_1) x_2) x_3
    let snd โ† some (Bitvec.ofInt' w โ†‘RHS')
    Bitvec.add? fst snd) =   do
  let fst โ† some (Bitvec.ofInt' w โ†‘RHS')
  let x โ† some (Bitvec.ofInt' w โ†‘Z')
  let x_1 โ† some (Bitvec.not (Bitvec.ofInt' w โ†‘C1))
  pure (Bitvec.sub fst (Bitvec.or x x_1))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (Z C1 RHS : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 11 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 10
                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘RHS))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 7
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 1))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.pair Context.Var.last
                                        (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1))
                                              (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Z)) Context.Var.last TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 15 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 14
                          (TSSA.pair Context.Var.last
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))) โˆ˜                       (fun prev =>
                          TSSA.assign prev 13
                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘RHS))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev
                                                  (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 12 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 11 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 10
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 1))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev
                                                  (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 8
                                      (TSSA.pair Context.Var.last
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                                   (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 6
                                          (TSSA.pair
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                                       (fun prev => TSSA.assign prev 5 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 4
                                              (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                                                Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 3 (TSSA.op (Op.not w) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 2
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1))
                                                    (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                               (fun prev =>
                                                  TSSA.assign prev 1
                                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Z)) Context.Var.last
                                                      TSSA.rgn0)) โˆ˜                                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

w, Z, C, RHS, Z', C1, RHS': โ„•

(Option.bind
    (Bitvec.add? (Bitvec.xor (Bitvec.and (Bitvec.ofInt' w โ†‘Z') (Bitvec.ofInt' w โ†‘C1)) (Bitvec.ofInt' w โ†‘C1))
      (Bitvec.ofInt' w 1))
    fun fst => Bitvec.add? fst (Bitvec.ofInt' w โ†‘RHS')) =   some (Bitvec.sub (Bitvec.ofInt' w โ†‘RHS') (Bitvec.or (Bitvec.ofInt' w โ†‘Z') (Bitvec.not (Bitvec.ofInt' w โ†‘C1))))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (Z C1 RHS : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 11 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 10
                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘RHS))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 7
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 1))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.pair Context.Var.last
                                        (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1))
                                              (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Z)) Context.Var.last TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 15 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 14
                          (TSSA.pair Context.Var.last
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))) โˆ˜                       (fun prev =>
                          TSSA.assign prev 13
                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘RHS))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev
                                                  (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 12 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 11 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 10
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 1))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev
                                                  (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 8
                                      (TSSA.pair Context.Var.last
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                                   (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 6
                                          (TSSA.pair
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                                       (fun prev => TSSA.assign prev 5 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 4
                                              (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                                                Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 3 (TSSA.op (Op.not w) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 2
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1))
                                                    (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                               (fun prev =>
                                                  TSSA.assign prev 1
                                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Z)) Context.Var.last
                                                      TSSA.rgn0)) โˆ˜                                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
Goals accomplished! ๐Ÿ™



-- Name:AddSub:1152
-- precondition: true
/-
  %r = add i1 %x, %y

=>
  %r = xor %x, %y

-/


open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
x: โ„•
x 
y: โ„•
y 
x: โ„•
x 
y: โ„•
y : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.248252
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
x: โ„•
x)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
y: โ„•
y)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:add 
w: โ„•
w %v3
  dsl_ret %v4
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.248252
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
x: โ„•
x)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
y: โ„•
y)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3
  dsl_ret %v4
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, xโœยน, yโœยน, xโœ, yโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 2
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘yโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘xโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 2
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘yโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘xโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, xโœยน, yโœยน, xโœ, yโœ: โ„•

(do
    let fst โ† some (Bitvec.ofInt' wโœ โ†‘xโœ)
    let snd โ† some (Bitvec.ofInt' wโœ โ†‘yโœ)
    Bitvec.add? fst snd) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘xโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘yโœ)
  pure (Bitvec.xor fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, xโœยน, yโœยน, xโœ, yโœ: โ„•

Bitvec.add? (Bitvec.ofInt' wโœ โ†‘xโœ) (Bitvec.ofInt' wโœ โ†‘yโœ) =   some (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘xโœ) (Bitvec.ofInt' wโœ โ†‘yโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1164
-- precondition: true
/-
  %na = sub 0, %a
  %c = add %na, %b

=>
  %na = sub 0, %a
  %c = sub %b, %a

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
b: โ„•
b 
a: โ„•
a 
b: โ„•
b : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.317669
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.319264
0)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:sub 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:add 
w: โ„•
w %v6
  dsl_ret %v7
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.317669
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.321514
0)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:sub 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v6 := pair:%v5 %v2;
  %v7 := op:sub 
w: โ„•
w %v6
  dsl_ret %v7
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 5
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ))
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 6
                (TSSA.pair Context.Var.last
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜             (fun prev =>
                TSSA.assign prev 5
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ))
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ 0)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let snd โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    Bitvec.add? (Bitvec.sub x x_1) snd) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  pure (Bitvec.sub fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

Bitvec.add? (Bitvec.sub (Bitvec.ofInt' wโœ 0) (Bitvec.ofInt' wโœ โ†‘aโœ)) (Bitvec.ofInt' wโœ โ†‘bโœ) =   some (Bitvec.sub (Bitvec.ofInt' wโœ โ†‘bโœ) (Bitvec.ofInt' wโœ โ†‘aโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1165
-- precondition: true
/-
  %na = sub 0, %a
  %nb = sub 0, %b
  %c = add %na, %nb

=>
  %ab = add %a, %b
  %na = sub 0, %a
  %nb = sub 0, %b
  %c = sub 0, %ab

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
b: โ„•
b 
a: โ„•
a 
b: โ„•
b : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.443697
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.446310
0)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:sub 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.444679
0)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:sub 
w: โ„•
w %v7;
  %v9 := pair:%v4 %v8;
  %v10 := op:add 
w: โ„•
w %v9
  dsl_ret %v10
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.443697
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:add 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.448583
0)) %v9999;
  %v6 := pair:%v5 %v1;
  %v7 := op:sub 
w: โ„•
w %v6;
  %v8 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.448080
0)) %v9999;
  %v9 := pair:%v8 %v2;
  %v10 := op:sub 
w: โ„•
w %v9;
  %v11 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.447535
0)) %v9999;
  %v12 := pair:%v11 %v4;
  %v13 := op:sub 
w: โ„•
w %v12
  dsl_ret %v13
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 12
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 11
                          (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 10 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 9
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8
                                (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 6
                                    (TSSA.pair Context.Var.last
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                              TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 9
                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 6
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ))
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                        TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) (Context.Var.prev Context.Var.last)
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 12
                (TSSA.pair Context.Var.last
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜             (fun prev =>
                TSSA.assign prev 11
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0))
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 10 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 9
                      (TSSA.pair Context.Var.last
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 12
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 11
                          (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 10 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 9
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8
                                (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 6
                                    (TSSA.pair Context.Var.last
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                              TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ 0)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ 0)
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    Bitvec.add? (Bitvec.sub x x_1) (Bitvec.sub x_2 x_3)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ 0)
  let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
  let snd โ† Bitvec.add? x x_1
  pure (Bitvec.sub fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 12
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 11
                          (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 10 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 9
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8
                                (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 6
                                    (TSSA.pair Context.Var.last
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                              TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

Bitvec.add? (Bitvec.sub (Bitvec.ofInt' wโœ 0) (Bitvec.ofInt' wโœ โ†‘aโœ))
    (Bitvec.sub (Bitvec.ofInt' wโœ 0) (Bitvec.ofInt' wโœ โ†‘bโœ)) =   Option.bind (Bitvec.add? (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ)) fun snd =>
    some (Bitvec.sub (Bitvec.ofInt' wโœ 0) snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 12
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 11
                          (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 10 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 9
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8
                                (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 6
                                    (TSSA.pair Context.Var.last
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                              TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1176
-- precondition: true
/-
  %nb = sub 0, %b
  %c = add %a, %nb

=>
  %nb = sub 0, %b
  %c = sub %a, %b

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
b: โ„•
b 
a: โ„•
a 
b: โ„•
b 
a: โ„•
a : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.639137
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.640732
0)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:sub 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v6 := pair:%v5 %v4;
  %v7 := op:add 
w: โ„•
w %v6
  dsl_ret %v7
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.639137
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.642982
0)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:sub 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v6 := pair:%v5 %v2;
  %v7 := op:sub 
w: โ„•
w %v6
  dsl_ret %v7
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (b a : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, bโœยน, aโœยน, bโœ, aโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜             (fun prev =>
                TSSA.assign prev 5
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ))
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 6
                (TSSA.pair Context.Var.last
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜             (fun prev =>
                TSSA.assign prev 5
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ))
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (b a : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, bโœยน, aโœยน, bโœ, aโœ: โ„•

(do
    let fst โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x โ† some (Bitvec.ofInt' wโœ 0)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    Bitvec.add? fst (Bitvec.sub x x_1)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
  pure (Bitvec.sub fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (b a : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, bโœยน, aโœยน, bโœ, aโœ: โ„•

Bitvec.add? (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.sub (Bitvec.ofInt' wโœ 0) (Bitvec.ofInt' wโœ โ†‘bโœ)) =   some (Bitvec.sub (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (b a : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1295
-- precondition: true
/-
  %aab = and %a, %b
  %aob = xor %a, %b
  %c = add %aab, %aob

=>
  %aab = and %a, %b
  %aob = xor %a, %b
  %c = or %a, %b

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
b: โ„•
b 
a: โ„•
a 
b: โ„•
b : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.764885
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:xor 
w: โ„•
w %v5;
  %v7 := pair:%v4 %v6;
  %v8 := op:add 
w: โ„•
w %v7
  dsl_ret %v8
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.764885
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:xor 
w: โ„•
w %v5;
  %v7 := pair:%v1 %v2;
  %v8 := op:or 
w: โ„•
w %v7
  dsl_ret %v8
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    Bitvec.add? (Bitvec.and x x_1) (Bitvec.xor x_2 x_3)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
  pure (Bitvec.or fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

Bitvec.add? (Bitvec.and (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))
    (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ)) =   some (Bitvec.or (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1309
-- precondition: true
/-
  %lhs = and %a, %b
  %rhs = or %a, %b
  %c = add %lhs, %rhs

=>
  %lhs = and %a, %b
  %rhs = or %a, %b
  %c = add %a, %b

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
b: โ„•
b 
a: โ„•
a 
b: โ„•
b : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.923425
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:or 
w: โ„•
w %v5;
  %v7 := pair:%v4 %v6;
  %v8 := op:add 
w: โ„•
w %v7
  dsl_ret %v8
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.923425
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:or 
w: โ„•
w %v5;
  %v7 := pair:%v1 %v2;
  %v8 := op:add 
w: โ„•
w %v7
  dsl_ret %v8
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    Bitvec.add? (Bitvec.and x x_1) (Bitvec.or x_2 x_3)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
  Bitvec.add? fst snd
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

Bitvec.add? (Bitvec.and (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))
    (Bitvec.or (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ)) =   Bitvec.add? (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1309-2
-- precondition: true
/-
  %lhs = and %a, %b
  %rhs = or %a, %b
  %c = add nsw %lhs, %rhs

=>
  %lhs = and %a, %b
  %rhs = or %a, %b
  %c = add nsw %a, %b

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
b: โ„•
b 
a: โ„•
a 
b: โ„•
b : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1080230
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:or 
w: โ„•
w %v5;
  %v7 := pair:%v4 %v6;
  %v8 := op:add 
w: โ„•
w %v7
  dsl_ret %v8
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1080230
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:or 
w: โ„•
w %v5;
  %v7 := pair:%v1 %v2;
  %v8 := op:add 
w: โ„•
w %v7
  dsl_ret %v8
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    Bitvec.add? (Bitvec.and x x_1) (Bitvec.or x_2 x_3)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
  Bitvec.add? fst snd
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

Bitvec.add? (Bitvec.and (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))
    (Bitvec.or (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ)) =   Bitvec.add? (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1309-3
-- precondition: true
/-
  %lhs = and %a, %b
  %rhs = or %a, %b
  %c = add nuw %lhs, %rhs

=>
  %lhs = and %a, %b
  %rhs = or %a, %b
  %c = add nuw %a, %b

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
b: โ„•
b 
a: โ„•
a 
b: โ„•
b : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1237035
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:or 
w: โ„•
w %v5;
  %v7 := pair:%v4 %v6;
  %v8 := op:add 
w: โ„•
w %v7
  dsl_ret %v8
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1237035
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:or 
w: โ„•
w %v5;
  %v7 := pair:%v1 %v2;
  %v8 := op:add 
w: โ„•
w %v7
  dsl_ret %v8
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    Bitvec.add? (Bitvec.and x x_1) (Bitvec.or x_2 x_3)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
  Bitvec.add? fst snd
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

Bitvec.add? (Bitvec.and (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))
    (Bitvec.or (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ)) =   Bitvec.add? (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1539
-- precondition: true
/-
  %na = sub 0, %a
  %r = sub %x, %na

=>
  %na = sub 0, %a
  %r = add %x, %a

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
x: โ„•
x 
a: โ„•
a 
x: โ„•
x : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1394089
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.1395684
0)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:sub 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
x: โ„•
x)) %v9999;
  %v6 := pair:%v5 %v4;
  %v7 := op:sub 
w: โ„•
w %v6
  dsl_ret %v7
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1394089
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.1397934
0)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:sub 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
x: โ„•
x)) %v9999;
  %v6 := pair:%v5 %v2;
  %v7 := op:add 
w: โ„•
w %v6
  dsl_ret %v7
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a x : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, xโœยน, aโœ, xโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜             (fun prev =>
                TSSA.assign prev 5
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘xโœ))
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 6
                (TSSA.pair Context.Var.last
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜             (fun prev =>
                TSSA.assign prev 5
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘xโœ))
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a x : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, xโœยน, aโœ, xโœ: โ„•

(do
    let fst โ† some (Bitvec.ofInt' wโœ โ†‘xโœ)
    let x โ† some (Bitvec.ofInt' wโœ 0)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    pure (Bitvec.sub fst (Bitvec.sub x x_1))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘xโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  Bitvec.add? fst snd
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a x : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, xโœยน, aโœ, xโœ: โ„•

some (Bitvec.sub (Bitvec.ofInt' wโœ โ†‘xโœ) (Bitvec.sub (Bitvec.ofInt' wโœ 0) (Bitvec.ofInt' wโœ โ†‘aโœ))) =   Bitvec.add? (Bitvec.ofInt' wโœ โ†‘xโœ) (Bitvec.ofInt' wโœ โ†‘aโœ)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a x : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1546
-- precondition: true
/-
  %na = sub nsw 0, %a
  %r = sub nsw %x, %na

=>
  %na = sub nsw 0, %a
  %r = add nsw %x, %a

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
x: โ„•
x 
a: โ„•
a 
x: โ„•
x : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1520260
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.1521855
0)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:sub 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
x: โ„•
x)) %v9999;
  %v6 := pair:%v5 %v4;
  %v7 := op:sub 
w: โ„•
w %v6
  dsl_ret %v7
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1520260
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.1524105
0)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:sub 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
x: โ„•
x)) %v9999;
  %v6 := pair:%v5 %v2;
  %v7 := op:add 
w: โ„•
w %v6
  dsl_ret %v7
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a x : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, xโœยน, aโœ, xโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜             (fun prev =>
                TSSA.assign prev 5
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘xโœ))
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 6
                (TSSA.pair Context.Var.last
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜             (fun prev =>
                TSSA.assign prev 5
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘xโœ))
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a x : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, xโœยน, aโœ, xโœ: โ„•

(do
    let fst โ† some (Bitvec.ofInt' wโœ โ†‘xโœ)
    let x โ† some (Bitvec.ofInt' wโœ 0)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    pure (Bitvec.sub fst (Bitvec.sub x x_1))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘xโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  Bitvec.add? fst snd
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a x : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, xโœยน, aโœ, xโœ: โ„•

some (Bitvec.sub (Bitvec.ofInt' wโœ โ†‘xโœ) (Bitvec.sub (Bitvec.ofInt' wโœ 0) (Bitvec.ofInt' wโœ โ†‘aโœ))) =   Bitvec.add? (Bitvec.ofInt' wโœ โ†‘xโœ) (Bitvec.ofInt' wโœ โ†‘aโœ)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a x : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w 0)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1556
-- precondition: true
/-
  %r = sub i1 %x, %y

=>
  %r = xor %x, %y

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
x: โ„•
x 
y: โ„•
y 
x: โ„•
x 
y: โ„•
y : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1645418
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
x: โ„•
x)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
y: โ„•
y)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:sub 
w: โ„•
w %v3
  dsl_ret %v4
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1645418
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
x: โ„•
x)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
y: โ„•
y)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3
  dsl_ret %v4
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, xโœยน, yโœยน, xโœ, yโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 2
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘yโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘xโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 2
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘yโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘xโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, xโœยน, yโœยน, xโœ, yโœ: โ„•

(do
    let fst โ† some (Bitvec.ofInt' wโœ โ†‘xโœ)
    let snd โ† some (Bitvec.ofInt' wโœ โ†‘yโœ)
    pure (Bitvec.sub fst snd)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘xโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘yโœ)
  pure (Bitvec.xor fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, xโœยน, yโœยน, xโœ, yโœ: โ„•

some (Bitvec.sub (Bitvec.ofInt' wโœ โ†‘xโœ) (Bitvec.ofInt' wโœ โ†‘yโœ)) =   some (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘xโœ) (Bitvec.ofInt' wโœ โ†‘yโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1560
-- precondition: true
/-
  %r = sub -1, %a

=>
  %r = xor %a, -1

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
a: โ„•
a : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1715764
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.1716337
1)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:sub 
w: โ„•
w %v3
  dsl_ret %v4
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1715764
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.1717798
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3
  dsl_ret %v4
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โˆ€ (a : โ„•),
      TSSA.eval
          (TSSA.ret
            (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
              TSSA.nop)
            Context.Var.last)
          e =         TSSA.eval
          (TSSA.ret
            (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
              TSSA.nop)
            Context.Var.last)
          e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, aโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 2
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 2
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โˆ€ (a : โ„•),
      TSSA.eval
          (TSSA.ret
            (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
              TSSA.nop)
            Context.Var.last)
          e =         TSSA.eval
          (TSSA.ret
            (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
              TSSA.nop)
            Context.Var.last)
          e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, aโœ: โ„•

(do
    let fst โ† some (Bitvec.ofInt' wโœ (-1))
    let snd โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    pure (Bitvec.sub fst snd)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.xor fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โˆ€ (a : โ„•),
      TSSA.eval
          (TSSA.ret
            (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
              TSSA.nop)
            Context.Var.last)
          e =         TSSA.eval
          (TSSA.ret
            (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
              TSSA.nop)
            Context.Var.last)
          e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, aโœ: โ„•

some (Bitvec.sub (Bitvec.ofInt' wโœ (-1)) (Bitvec.ofInt' wโœ โ†‘aโœ)) =   some (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ (-1)))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โˆ€ (a : โ„•),
      TSSA.eval
          (TSSA.ret
            (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
              TSSA.nop)
            Context.Var.last)
          e =         TSSA.eval
          (TSSA.ret
            (((fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
              TSSA.nop)
            Context.Var.last)
          e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1614
-- precondition: true
/-
  %Op1 = add %X, %Y
  %r = sub %X, %Op1

=>
  %Op1 = add %X, %Y
  %r = sub 0, %Y

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
X: โ„•
X 
Y: โ„•
Y 
X: โ„•
X 
Y: โ„•
Y : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1812305
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
X: โ„•
X)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
Y: โ„•
Y)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:add 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v4;
  %v6 := op:sub 
w: โ„•
w %v5
  dsl_ret %v6
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1812305
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
X: โ„•
X)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
Y: โ„•
Y)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:add 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.1814452
0)) %v9999;
  %v6 := pair:%v5 %v2;
  %v7 := op:sub 
w: โ„•
w %v6
  dsl_ret %v7
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (X Y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Xโœยน, Yโœยน, Xโœ, Yโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 5
                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 2
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Yโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Xโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 6
                (TSSA.pair Context.Var.last
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜             (fun prev =>
                TSSA.assign prev 5
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0))
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Yโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Xโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (X Y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Xโœยน, Yโœยน, Xโœ, Yโœ: โ„•

(do
    let fst โ† some (Bitvec.ofInt' wโœ โ†‘Xโœ)
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Xโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Yโœ)
    let snd โ† Bitvec.add? x x_1
    pure (Bitvec.sub fst snd)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ 0)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Yโœ)
  pure (Bitvec.sub fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (X Y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Xโœยน, Yโœยน, Xโœ, Yโœ: โ„•

(Option.bind (Bitvec.add? (Bitvec.ofInt' wโœ โ†‘Xโœ) (Bitvec.ofInt' wโœ โ†‘Yโœ)) fun snd =>
    some (Bitvec.sub (Bitvec.ofInt' wโœ โ†‘Xโœ) snd)) =   some (Bitvec.sub (Bitvec.ofInt' wโœ 0) (Bitvec.ofInt' wโœ โ†‘Yโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (X Y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.add w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1619
-- precondition: true
/-
  %Op0 = sub %X, %Y
  %r = sub %Op0, %X

=>
  %Op0 = sub %X, %Y
  %r = sub 0, %Y

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
X: โ„•
X 
Y: โ„•
Y 
X: โ„•
X 
Y: โ„•
Y : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1939036
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
X: โ„•
X)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
Y: โ„•
Y)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:sub 
w: โ„•
w %v3;
  %v5 := pair:%v4 %v1;
  %v6 := op:sub 
w: โ„•
w %v5
  dsl_ret %v6
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.1939036
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
X: โ„•
X)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
Y: โ„•
Y)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:sub 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
0: ?m.1941183
0)) %v9999;
  %v6 := pair:%v5 %v2;
  %v7 := op:sub 
w: โ„•
w %v6
  dsl_ret %v7
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (X Y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Xโœยน, Yโœยน, Xโœ, Yโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 5
                (TSSA.pair Context.Var.last
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 2
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Yโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Xโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 6
                (TSSA.pair Context.Var.last
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜             (fun prev =>
                TSSA.assign prev 5
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ 0))
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Yโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Xโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (X Y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Xโœยน, Yโœยน, Xโœ, Yโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Xโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Yโœ)
    let snd โ† some (Bitvec.ofInt' wโœ โ†‘Xโœ)
    pure (Bitvec.sub (Bitvec.sub x x_1) snd)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ 0)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Yโœ)
  pure (Bitvec.sub fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (X Y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Xโœยน, Yโœยน, Xโœ, Yโœ: โ„•

some (Bitvec.sub (Bitvec.sub (Bitvec.ofInt' wโœ โ†‘Xโœ) (Bitvec.ofInt' wโœ โ†‘Yโœ)) (Bitvec.ofInt' wโœ โ†‘Xโœ)) =   some (Bitvec.sub (Bitvec.ofInt' wโœ 0) (Bitvec.ofInt' wโœ โ†‘Yโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (X Y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w 0))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘Y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘X)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AddSub:1624
-- precondition: true
/-
  %Op0 = or %A, %B
  %Op1 = xor %A, %B
  %r = sub %Op0, %Op1

=>
  %Op0 = or %A, %B
  %Op1 = xor %A, %B
  %r = and %A, %B

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
A: โ„•
A 
B: โ„•
B : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.2066143
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:or 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:xor 
w: โ„•
w %v5;
  %v7 := pair:%v4 %v6;
  %v8 := op:sub 
w: โ„•
w %v7
  dsl_ret %v8
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.2066143
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:or 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:xor 
w: โ„•
w %v5;
  %v7 := pair:%v1 %v2;
  %v8 := op:and 
w: โ„•
w %v7
  dsl_ret %v8
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.sub wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    pure (Bitvec.sub (Bitvec.or x x_1) (Bitvec.xor x_2 x_3))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  pure (Bitvec.and fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

some
    (Bitvec.sub (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
      (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))) =   some (Bitvec.and (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.sub w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:1230  ~A & ~B -> ~(A | B)
-- precondition: true
/-
  %op0 = xor %notOp0, -1
  %op1 = xor %notOp1, -1
  %r = and %op0, %op1

=>
  %or = or %notOp0, %notOp1
  %op0 = xor %notOp0, -1
  %op1 = xor %notOp1, -1
  %r = xor %or, -1

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
notOp0: โ„•
notOp0 
notOp1: โ„•
notOp1 
notOp0: โ„•
notOp0 
notOp1: โ„•
notOp1 : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.2227269
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
notOp0: โ„•
notOp0)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.2229545
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
notOp1: โ„•
notOp1)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.2228005
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v4 %v8;
  %v10 := op:and 
w: โ„•
w %v9
  dsl_ret %v10
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.2227269
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
notOp0: โ„•
notOp0)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
notOp1: โ„•
notOp1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:or 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.2231986
1)) %v9999;
  %v6 := pair:%v1 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.2231461
1)) %v9999;
  %v9 := pair:%v2 %v8;
  %v10 := op:xor 
w: โ„•
w %v9;
  %v11 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.2230898
1)) %v9999;
  %v12 := pair:%v4 %v11;
  %v13 := op:xor 
w: โ„•
w %v12
  dsl_ret %v13
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (notOp0 notOp1 : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp1))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp0)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 12
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 11
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 9
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8
                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 6
                                    (TSSA.pair
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp1))
                                              (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp0)) Context.Var.last
                                                TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, notOp0โœยน, notOp1โœยน, notOp0โœ, notOp1โœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 9
                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 6
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                        TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘notOp1โœ))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘notOp0โœ)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 12
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                  Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 11
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 9
                      (TSSA.pair
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                        Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘notOp1โœ)) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘notOp0โœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (notOp0 notOp1 : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp1))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp0)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 12
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 11
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 9
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8
                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 6
                                    (TSSA.pair
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp1))
                                              (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp0)) Context.Var.last
                                                TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, notOp0โœยน, notOp1โœยน, notOp0โœ, notOp1โœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘notOp0โœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘notOp1โœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ (-1))
    pure (Bitvec.and (Bitvec.xor x x_1) (Bitvec.xor x_2 x_3))) =   do
  let x โ† some (Bitvec.ofInt' wโœ โ†‘notOp0โœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘notOp1โœ)
  let snd โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.xor (Bitvec.or x x_1) snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (notOp0 notOp1 : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp1))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp0)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 12
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 11
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 9
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8
                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 6
                                    (TSSA.pair
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp1))
                                              (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp0)) Context.Var.last
                                                TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, notOp0โœยน, notOp1โœยน, notOp0โœ, notOp1โœ: โ„•

some
    (Bitvec.and (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘notOp0โœ) (Bitvec.ofInt' wโœ (-1)))
      (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘notOp1โœ) (Bitvec.ofInt' wโœ (-1)))) =   some (Bitvec.xor (Bitvec.or (Bitvec.ofInt' wโœ โ†‘notOp0โœ) (Bitvec.ofInt' wโœ โ†‘notOp1โœ)) (Bitvec.ofInt' wโœ (-1)))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (notOp0 notOp1 : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp1))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp0)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 12
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 11
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 9
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8
                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 6
                                    (TSSA.pair
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp1))
                                              (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘notOp0)) Context.Var.last
                                                TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:1241 (A|B) & ~(A&B) => A^B
-- precondition: true
/-
  %op0 = or %A, %B
  %notOp1 = and %A, %B
  %op1 = xor %notOp1, -1
  %r = and %op0, %op1

=>
  %op0 = or %A, %B
  %notOp1 = and %A, %B
  %op1 = xor %notOp1, -1
  %r = xor %A, %B

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
A: โ„•
A 
B: โ„•
B : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.2426273
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:or 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:and 
w: โ„•
w %v5;
  %v7 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.2427017
1)) %v9999;
  %v8 := pair:%v6 %v7;
  %v9 := op:xor 
w: โ„•
w %v8;
  %v10 := pair:%v4 %v9;
  %v11 := op:and 
w: โ„•
w %v10
  dsl_ret %v11
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.2426273
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:or 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:and 
w: โ„•
w %v5;
  %v7 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.2430771
1)) %v9999;
  %v8 := pair:%v6 %v7;
  %v9 := op:xor 
w: โ„•
w %v8;
  %v10 := pair:%v1 %v2;
  %v11 := op:xor 
w: โ„•
w %v10
  dsl_ret %v11
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 7
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 6 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 7
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 6 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 7
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                            (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 7
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                            (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 7
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 6 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 7
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 6 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_4 โ† some (Bitvec.ofInt' wโœ (-1))
    pure (Bitvec.and (Bitvec.or x x_1) (Bitvec.xor (Bitvec.and x_2 x_3) x_4))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  pure (Bitvec.xor fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 7
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 6 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 7
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 6 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

some
    (Bitvec.and (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
      (Bitvec.xor (Bitvec.and (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Bitvec.ofInt' wโœ (-1)))) =   some (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 7
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 6 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 7
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 6 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:1247 ~(A&B) & (A|B) => A^B
-- precondition: true
/-
  %notOp0 = and %A, %B
  %op0 = xor %notOp0, -1
  %op1 = or %A, %B
  %r = and %op0, %op1

=>
  %notOp0 = and %A, %B
  %op0 = xor %notOp0, -1
  %op1 = or %A, %B
  %r = xor %A, %B

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
A: โ„•
A 
B: โ„•
B : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.2632371
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.2633518
1)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := pair:%v1 %v2;
  %v9 := op:or 
w: โ„•
w %v8;
  %v10 := pair:%v7 %v9;
  %v11 := op:and 
w: โ„•
w %v10
  dsl_ret %v11
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.2632371
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.2637201
1)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := pair:%v1 %v2;
  %v9 := op:or 
w: โ„•
w %v8;
  %v10 := pair:%v1 %v2;
  %v11 := op:xor 
w: โ„•
w %v10
  dsl_ret %v11
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10 (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 8
                    (TSSA.pair
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 8
                    (TSSA.pair
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_4 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    pure (Bitvec.and (Bitvec.xor (Bitvec.and x x_1) x_2) (Bitvec.or x_3 x_4))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  pure (Bitvec.xor fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

some
    (Bitvec.and (Bitvec.xor (Bitvec.and (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Bitvec.ofInt' wโœ (-1)))
      (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))) =   some (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:1253 A & (A^B) -> A & ~B
-- precondition: true
/-
  %op0 = xor %A, %B
  %r = and %op0, %A

=>
  %notB = xor %B, -1
  %op0 = xor %A, %B
  %r = and %A, %notB

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
B: โ„•
B 
A: โ„•
A : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.2835586
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := pair:%v4 %v1;
  %v6 := op:and 
w: โ„•
w %v5
  dsl_ret %v6
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.2835586
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.2838590
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v6 := pair:%v5 %v1;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := pair:%v5 %v4;
  %v9 := op:and 
w: โ„•
w %v8
  dsl_ret %v9
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Bโœ, Aโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 5
                (TSSA.pair Context.Var.last
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 2
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 6
                    (TSSA.pair Context.Var.last
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                              TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Bโœ, Aโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let snd โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    pure (Bitvec.and (Bitvec.xor x x_1) snd)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let x โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.and fst (Bitvec.xor x x_1))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Bโœ, Aโœ: โ„•

some (Bitvec.and (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Bitvec.ofInt' wโœ โ†‘Aโœ)) =   some (Bitvec.and (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Bโœ) (Bitvec.ofInt' wโœ (-1))))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:1280 (~A|B)&A -> A&B
-- precondition: true
/-
  %nA = xor %A, -1
  %op0 = or %nA, %B
  %r = and %op0, %A

=>
  %nA = xor %A, -1
  %op0 = or %nA, %B
  %r = and %A, %B

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
A: โ„•
A 
B: โ„•
B : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.2998502
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.2999842
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:or 
w: โ„•
w %v6;
  %v8 := pair:%v7 %v1;
  %v9 := op:and 
w: โ„•
w %v8
  dsl_ret %v9
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.2998502
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.3002827
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:or 
w: โ„•
w %v6;
  %v8 := pair:%v1 %v5;
  %v9 := op:and 
w: โ„•
w %v8
  dsl_ret %v9
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair Context.Var.last
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                              TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                  (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                              TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let snd โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    pure (Bitvec.and (Bitvec.or (Bitvec.xor x x_1) x_2) snd)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  pure (Bitvec.and fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

some
    (Bitvec.and (Bitvec.or (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘Bโœ))
      (Bitvec.ofInt' wโœ โ†‘Aโœ)) =   some (Bitvec.and (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:1288 (A ^ B) & ((B ^ C) ^ A) -> (A ^ B) & ~C
-- precondition: true
/-
  %op0 = xor %A, %B
  %x = xor %B, %C
  %op1 = xor %x, %A
  %r = and %op0, %op1

=>
  %op0 = xor %A, %B
  %negC = xor %C, -1
  %x = xor %B, %C
  %op1 = xor %x, %A
  %r = and %op0, %negC

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
C: โ„•
C 
A: โ„•
A 
B: โ„•
B 
C: โ„•
C : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.3167870
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
C: โ„•
C)) %v9999;
  %v6 := pair:%v2 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := pair:%v7 %v1;
  %v9 := op:xor 
w: โ„•
w %v8;
  %v10 := pair:%v4 %v9;
  %v11 := op:and 
w: โ„•
w %v10
  dsl_ret %v11
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.3167870
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
C: โ„•
C)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.3172610
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v2 %v5;
  %v10 := op:xor 
w: โ„•
w %v9;
  %v11 := pair:%v10 %v1;
  %v12 := op:xor 
w: โ„•
w %v11;
  %v13 := pair:%v4 %v8;
  %v14 := op:and 
w: โ„•
w %v13
  dsl_ret %v14
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A B C : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            Context.Var.last)) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 13
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 11
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                           (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 9
                                  (TSSA.pair
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                               (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 7
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 6
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 5
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 3
                                              (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 2
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                                  (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 1
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last
                                                    TSSA.rgn0)) โˆ˜                                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Cโœยน, Aโœ, Bโœ, Cโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 8
                    (TSSA.pair Context.Var.last
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Cโœ))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 13
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜             (fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 11
                    (TSSA.pair Context.Var.last
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                 (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Cโœ))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A B C : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            Context.Var.last)) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 13
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 11
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                           (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 9
                                  (TSSA.pair
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                               (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 7
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 6
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 5
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 3
                                              (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 2
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                                  (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 1
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last
                                                    TSSA.rgn0)) โˆ˜                                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Cโœยน, Aโœ, Bโœ, Cโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘Cโœ)
    let x_4 โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    pure (Bitvec.and (Bitvec.xor x x_1) (Bitvec.xor (Bitvec.xor x_2 x_3) x_4))) =   do
  let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Cโœ)
  let x_3 โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.and (Bitvec.xor x x_1) (Bitvec.xor x_2 x_3))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A B C : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            Context.Var.last)) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 13
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 11
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                           (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 9
                                  (TSSA.pair
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                               (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 7
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 6
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 5
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 3
                                              (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 2
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                                  (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 1
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last
                                                    TSSA.rgn0)) โˆ˜                                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Cโœยน, Aโœ, Bโœ, Cโœ: โ„•

some
    (Bitvec.and (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
      (Bitvec.xor (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Bโœ) (Bitvec.ofInt' wโœ โ†‘Cโœ)) (Bitvec.ofInt' wโœ โ†‘Aโœ))) =   some
    (Bitvec.and (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
      (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Cโœ) (Bitvec.ofInt' wโœ (-1))))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A B C : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            Context.Var.last)) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 13
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 11
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                           (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 9
                                  (TSSA.pair
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                               (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 7
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 6
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 5
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 3
                                              (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 2
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                                  (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 1
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last
                                                    TSSA.rgn0)) โˆ˜                                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:1294 (A | B) & ((~A) ^ B) -> (A & B)
-- precondition: true
/-
  %op0 = or %A, %B
  %x = xor %A, -1
  %op1 = xor %x, %B
  %r = and %op0, %op1

=>
  %op0 = or %A, %B
  %x = xor %A, -1
  %op1 = xor %x, %B
  %r = and %A, %B

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
A: โ„•
A 
B: โ„•
B : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.3438640
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:or 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.3439786
1)) %v9999;
  %v6 := pair:%v1 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := pair:%v7 %v2;
  %v9 := op:xor 
w: โ„•
w %v8;
  %v10 := pair:%v4 %v9;
  %v11 := op:and 
w: โ„•
w %v10
  dsl_ret %v11
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.3438640
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:or 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.3443542
1)) %v9999;
  %v6 := pair:%v1 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := pair:%v7 %v2;
  %v9 := op:xor 
w: โ„•
w %v8;
  %v10 := pair:%v1 %v2;
  %v11 := op:and 
w: โ„•
w %v10
  dsl_ret %v11
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 8
                    (TSSA.pair Context.Var.last
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 8
                    (TSSA.pair Context.Var.last
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_4 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    pure (Bitvec.and (Bitvec.or x x_1) (Bitvec.xor (Bitvec.xor x_2 x_3) x_4))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  pure (Bitvec.and fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

some
    (Bitvec.and (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
      (Bitvec.xor (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘Bโœ))) =   some (Bitvec.and (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2113   ((~A & B) | A) -> (A | B)
-- precondition: true
/-
  %negA = xor %A, -1
  %op0 = and %negA, %B
  %r = or %op0, %A

=>
  %negA = xor %A, -1
  %op0 = and %negA, %B
  %r = or %A, %B

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
A: โ„•
A 
B: โ„•
B : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.3644160
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.3645500
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:and 
w: โ„•
w %v6;
  %v8 := pair:%v7 %v1;
  %v9 := op:or 
w: โ„•
w %v8
  dsl_ret %v9
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.3644160
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.3648485
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:and 
w: โ„•
w %v6;
  %v8 := pair:%v1 %v5;
  %v9 := op:or 
w: โ„•
w %v8
  dsl_ret %v9
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair Context.Var.last
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                              TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                  (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                              TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let snd โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    pure (Bitvec.or (Bitvec.and (Bitvec.xor x x_1) x_2) snd)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  pure (Bitvec.or fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

some
    (Bitvec.or (Bitvec.and (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘Bโœ))
      (Bitvec.ofInt' wโœ โ†‘Aโœ)) =   some (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2118   ((A & B) | ~A) -> (~A | B)
-- precondition: true
/-
  %negA = xor %A, -1
  %op0 = and %A, %B
  %r = or %op0, %negA

=>
  %negA = xor %A, -1
  %op0 = and %A, %B
  %r = or %negA, %B

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
A: โ„•
A 
B: โ„•
B : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.3813432
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.3814772
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v6 := pair:%v1 %v5;
  %v7 := op:and 
w: โ„•
w %v6;
  %v8 := pair:%v7 %v4;
  %v9 := op:or 
w: โ„•
w %v8
  dsl_ret %v9
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.3813432
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.3817757
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v6 := pair:%v1 %v5;
  %v7 := op:and 
w: โ„•
w %v6;
  %v8 := pair:%v4 %v5;
  %v9 := op:or 
w: โ„•
w %v8
  dsl_ret %v9
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair Context.Var.last
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 6
                    (TSSA.pair
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                      Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                              TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                  (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 6
                    (TSSA.pair
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                      Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                              TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ (-1))
    pure (Bitvec.or (Bitvec.and x x_1) (Bitvec.xor x_2 x_3))) =   do
  let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  pure (Bitvec.or (Bitvec.xor x x_1) snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

some
    (Bitvec.or (Bitvec.and (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
      (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ (-1)))) =   some (Bitvec.or (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘Bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2123   (A & (~B)) | (A ^ B) -> (A ^ B)
-- precondition: true
/-
  %negB = xor %B, -1
  %op0 = and %A, %negB
  %op1 = xor %A, %B
  %r = or %op0, %op1

=>
  %negB = xor %B, -1
  %op0 = and %A, %negB
  %op1 = xor %A, %B
  %r = xor %A, %B

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
B: โ„•
B 
A: โ„•
A 
B: โ„•
B 
A: โ„•
A : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.3985722
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.3987434
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v6 := pair:%v5 %v4;
  %v7 := op:and 
w: โ„•
w %v6;
  %v8 := pair:%v5 %v1;
  %v9 := op:xor 
w: โ„•
w %v8;
  %v10 := pair:%v7 %v9;
  %v11 := op:or 
w: โ„•
w %v10
  dsl_ret %v11
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.3985722
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.3990759
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v6 := pair:%v5 %v4;
  %v7 := op:and 
w: โ„•
w %v6;
  %v8 := pair:%v5 %v1;
  %v9 := op:xor 
w: โ„•
w %v8;
  %v10 := pair:%v5 %v1;
  %v11 := op:xor 
w: โ„•
w %v10
  dsl_ret %v11
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Bโœยน, Aโœยน, Bโœ, Aโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10 (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 8
                    (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10
                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 8
                    (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Bโœยน, Aโœยน, Bโœ, Aโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_4 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    pure (Bitvec.or (Bitvec.and x (Bitvec.xor x_1 x_2)) (Bitvec.xor x_3 x_4))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  pure (Bitvec.xor fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Bโœยน, Aโœยน, Bโœ, Aโœ: โ„•

some
    (Bitvec.or (Bitvec.and (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Bโœ) (Bitvec.ofInt' wโœ (-1))))
      (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))) =   some (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2188
-- precondition: true
/-
  %C = xor %D, -1
  %B = xor %A, -1
  %op0 = and %A, %C
  %op1 = and %B, %D
  %r = or %op0, %op1

=>
  %C = xor %D, -1
  %B = xor %A, -1
  %op0 = and %A, %C
  %op1 = and %B, %D
  %r = xor %A, %D

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
D: โ„•
D 
A: โ„•
A 
D: โ„•
D 
A: โ„•
A : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.4187175
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
D: โ„•
D)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.4190249
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.4188715
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v5 %v4;
  %v10 := op:and 
w: โ„•
w %v9;
  %v11 := pair:%v8 %v1;
  %v12 := op:and 
w: โ„•
w %v11;
  %v13 := pair:%v10 %v12;
  %v14 := op:or 
w: โ„•
w %v13
  dsl_ret %v14
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.4187175
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
D: โ„•
D)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.4194160
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.4192657
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v5 %v4;
  %v10 := op:and 
w: โ„•
w %v9;
  %v11 := pair:%v8 %v1;
  %v12 := op:and 
w: โ„•
w %v11;
  %v13 := pair:%v5 %v1;
  %v14 := op:xor 
w: โ„•
w %v13
  dsl_ret %v14
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (D A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘D)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘D)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Dโœยน, Aโœยน, Dโœ, Aโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 13 (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 11
                    (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                 (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Dโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 13
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))) โˆ˜             (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 11
                    (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                 (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Dโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (D A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘D)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘D)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Dโœยน, Aโœยน, Dโœ, Aโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Dโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_4 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_5 โ† some (Bitvec.ofInt' wโœ โ†‘Dโœ)
    pure (Bitvec.or (Bitvec.and x (Bitvec.xor x_1 x_2)) (Bitvec.and (Bitvec.xor x_3 x_4) x_5))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Dโœ)
  pure (Bitvec.xor fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (D A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘D)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘D)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Dโœยน, Aโœยน, Dโœ, Aโœ: โ„•

some
    (Bitvec.or (Bitvec.and (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Dโœ) (Bitvec.ofInt' wโœ (-1))))
      (Bitvec.and (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘Dโœ))) =   some (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Dโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (D A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘D)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘D)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2231  (A ^ B) | ((B ^ C) ^ A) -> (A ^ B) | C
-- precondition: true
/-
  %op0 = xor %A, %B
  %x = xor %B, %C
  %op1 = xor %x, %A
  %r = or %op0, %op1

=>
  %op0 = xor %A, %B
  %x = xor %B, %C
  %op1 = xor %x, %A
  %r = or %op0, %C

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
C: โ„•
C 
A: โ„•
A 
B: โ„•
B 
C: โ„•
C : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.4430033
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
C: โ„•
C)) %v9999;
  %v6 := pair:%v2 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := pair:%v7 %v1;
  %v9 := op:xor 
w: โ„•
w %v8;
  %v10 := pair:%v4 %v9;
  %v11 := op:or 
w: โ„•
w %v10
  dsl_ret %v11
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.4430033
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
C: โ„•
C)) %v9999;
  %v6 := pair:%v2 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := pair:%v7 %v1;
  %v9 := op:xor 
w: โ„•
w %v8;
  %v10 := pair:%v4 %v5;
  %v11 := op:or 
w: โ„•
w %v10
  dsl_ret %v11
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A B C : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            Context.Var.last)) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Cโœยน, Aโœ, Bโœ, Cโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 8
                    (TSSA.pair Context.Var.last
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Cโœ))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 8
                    (TSSA.pair Context.Var.last
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Cโœ))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A B C : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            Context.Var.last)) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Cโœยน, Aโœ, Bโœ, Cโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘Cโœ)
    let x_4 โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    pure (Bitvec.or (Bitvec.xor x x_1) (Bitvec.xor (Bitvec.xor x_2 x_3) x_4))) =   do
  let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Cโœ)
  pure (Bitvec.or (Bitvec.xor x x_1) snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A B C : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            Context.Var.last)) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Cโœยน, Aโœ, Bโœ, Cโœ: โ„•

some
    (Bitvec.or (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
      (Bitvec.xor (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Bโœ) (Bitvec.ofInt' wโœ โ†‘Cโœ)) (Bitvec.ofInt' wโœ โ†‘Aโœ))) =   some (Bitvec.or (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Bitvec.ofInt' wโœ โ†‘Cโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A B C : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            Context.Var.last)) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2243  ((B | C) & A) | B -> B | (A & C)
-- precondition: true
/-
  %o = or %B, %C
  %op0 = and %o, %A
  %r = or %op0, %B

=>
  %a = and %A, %C
  %o = or %B, %C
  %op0 = and %o, %A
  %r = or %B, %a

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
B: โ„•
B 
C: โ„•
C 
A: โ„•
A 
A: โ„•
A 
C: โ„•
C 
B: โ„•
B : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.4637788
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
C: โ„•
C)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:or 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:and 
w: โ„•
w %v6;
  %v8 := pair:%v7 %v1;
  %v9 := op:or 
w: โ„•
w %v8
  dsl_ret %v9
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.4637788
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
C: โ„•
C)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v6 := pair:%v5 %v2;
  %v7 := op:or 
w: โ„•
w %v6;
  %v8 := pair:%v7 %v1;
  %v9 := op:and 
w: โ„•
w %v8;
  %v10 := pair:%v5 %v4;
  %v11 := op:or 
w: โ„•
w %v10
  dsl_ret %v11
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A C B : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.pair Context.Var.last
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair Context.Var.last
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Bโœยน, Cโœยน, Aโœยน, Aโœ, Cโœ, Bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair Context.Var.last
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Cโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10
                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 8
                    (TSSA.pair Context.Var.last
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair Context.Var.last
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Cโœ)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A C B : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.pair Context.Var.last
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair Context.Var.last
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Bโœยน, Cโœยน, Aโœยน, Aโœ, Cโœ, Bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Cโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let snd โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    pure (Bitvec.or (Bitvec.and (Bitvec.or x x_1) x_2) snd)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Cโœ)
  pure (Bitvec.or fst (Bitvec.and x x_1))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A C B : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.pair Context.Var.last
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair Context.Var.last
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Bโœยน, Cโœยน, Aโœยน, Aโœ, Cโœ, Bโœ: โ„•

some
    (Bitvec.or (Bitvec.and (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Bโœ) (Bitvec.ofInt' wโœ โ†‘Cโœ)) (Bitvec.ofInt' wโœ โ†‘Aโœ))
      (Bitvec.ofInt' wโœ โ†‘Bโœ)) =   some (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Bโœ) (Bitvec.and (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Cโœ)))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A C B : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.pair Context.Var.last
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 10
                          (TSSA.pair
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                       (fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.pair Context.Var.last
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair Context.Var.last
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C)) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2247  (~A | ~B) == (~(A & B))
-- precondition: true
/-
  %na = xor %A, -1
  %nb = xor %B, -1
  %r = or %na, %nb

=>
  %a = and %A, %B
  %na = xor %A, -1
  %nb = xor %B, -1
  %r = xor %a, -1

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
A: โ„•
A 
B: โ„•
B : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.4836786
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.4839062
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.4837522
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v4 %v8;
  %v10 := op:or 
w: โ„•
w %v9
  dsl_ret %v10
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.4836786
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.4841503
1)) %v9999;
  %v6 := pair:%v1 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.4840978
1)) %v9999;
  %v9 := pair:%v2 %v8;
  %v10 := op:xor 
w: โ„•
w %v9;
  %v11 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.4840415
1)) %v9999;
  %v12 := pair:%v4 %v11;
  %v13 := op:xor 
w: โ„•
w %v12
  dsl_ret %v13
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 12
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 11
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 9
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8
                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 6
                                    (TSSA.pair
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                              TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 9
                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 6
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                        TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 12
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                  Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 11
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 9
                      (TSSA.pair
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                        Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 12
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 11
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 9
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8
                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 6
                                    (TSSA.pair
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                              TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ (-1))
    pure (Bitvec.or (Bitvec.xor x x_1) (Bitvec.xor x_2 x_3))) =   do
  let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  let snd โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.xor (Bitvec.and x x_1) snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 12
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 11
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 9
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8
                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 6
                                    (TSSA.pair
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                              TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

some
    (Bitvec.or (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ (-1)))
      (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Bโœ) (Bitvec.ofInt' wโœ (-1)))) =   some (Bitvec.xor (Bitvec.and (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Bitvec.ofInt' wโœ (-1)))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 13 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 12
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 11
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 9
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 8
                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 6
                                    (TSSA.pair
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 5
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 3
                                          (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 2
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                              TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 1
                                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2263
-- precondition: true
/-
  %op1 = xor %op0, %B
  %r = or %op0, %op1

=>
  %op1 = xor %op0, %B
  %r = or %op0, %B

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
op0: โ„•
op0 
B: โ„•
B 
op0: โ„•
op0 
B: โ„•
B : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.5033756
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
op0: โ„•
op0)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v4;
  %v6 := op:or 
w: โ„•
w %v5
  dsl_ret %v6
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.5033756
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
op0: โ„•
op0)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:or 
w: โ„•
w %v5
  dsl_ret %v6
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (op0 B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op0)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op0)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, op0โœยน, Bโœยน, op0โœ, Bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 5
                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 2
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘op0โœ)) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 5
                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                  (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 2
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘op0โœ)) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (op0 B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op0)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op0)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, op0โœยน, Bโœยน, op0โœ, Bโœ: โ„•

(do
    let fst โ† some (Bitvec.ofInt' wโœ โ†‘op0โœ)
    let x โ† some (Bitvec.ofInt' wโœ โ†‘op0โœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    pure (Bitvec.or fst (Bitvec.xor x x_1))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘op0โœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  pure (Bitvec.or fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (op0 B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op0)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op0)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, op0โœยน, Bโœยน, op0โœ, Bโœ: โ„•

some (Bitvec.or (Bitvec.ofInt' wโœ โ†‘op0โœ) (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘op0โœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))) =   some (Bitvec.or (Bitvec.ofInt' wโœ โ†‘op0โœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (op0 B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op0)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op0)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2264
-- precondition: true
/-
  %na = xor %A, -1
  %op1 = xor %na, %B
  %r = or %A, %op1

=>
  %nb = xor %B, -1
  %na = xor %A, -1
  %op1 = xor %na, %B
  %r = or %A, %nb

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
B: โ„•
B 
A: โ„•
A : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.5160094
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.5161434
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := pair:%v1 %v7;
  %v9 := op:or 
w: โ„•
w %v8
  dsl_ret %v9
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.5160094
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.5165791
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.5164288
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v8 %v1;
  %v10 := op:xor 
w: โ„•
w %v9;
  %v11 := pair:%v5 %v4;
  %v12 := op:or 
w: โ„•
w %v11
  dsl_ret %v12
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Bโœ, Aโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                              TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 11
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜             (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 9
                    (TSSA.pair Context.Var.last
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                 (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 6
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ))
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Bโœ, Aโœ: โ„•

(do
    let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    pure (Bitvec.or fst (Bitvec.xor (Bitvec.xor x x_1) x_2))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let x โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.or fst (Bitvec.xor x x_1))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Bโœ, Aโœ: โ„•

some
    (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ)
      (Bitvec.xor (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘Bโœ))) =   some (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Bโœ) (Bitvec.ofInt' wโœ (-1))))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2265
-- precondition: true
/-
  %op0 = and %A, %B
  %op1 = xor %A, %B
  %r = or %op0, %op1

=>
  %op0 = and %A, %B
  %op1 = xor %A, %B
  %r = or %A, %B

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
A: โ„•
A 
B: โ„•
B : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.5359281
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:xor 
w: โ„•
w %v5;
  %v7 := pair:%v4 %v6;
  %v8 := op:or 
w: โ„•
w %v7
  dsl_ret %v8
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.5359281
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:xor 
w: โ„•
w %v5;
  %v7 := pair:%v1 %v2;
  %v8 := op:or 
w: โ„•
w %v7
  dsl_ret %v8
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    pure (Bitvec.or (Bitvec.and x x_1) (Bitvec.xor x_2 x_3))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  pure (Bitvec.or fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

some
    (Bitvec.or (Bitvec.and (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
      (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))) =   some (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2284
-- precondition: true
/-
  %o = or %A, %B
  %op1 = xor %o, -1
  %r = or %A, %op1

=>
  %not = xor %B, -1
  %o = or %A, %B
  %op1 = xor %o, -1
  %r = or %A, %not

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
B: โ„•
B 
A: โ„•
A : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.5520460
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:or 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.5521212
1)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := pair:%v1 %v7;
  %v9 := op:or 
w: โ„•
w %v8
  dsl_ret %v9
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.5520460
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.5526436
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v6 := pair:%v5 %v1;
  %v7 := op:or 
w: โ„•
w %v6;
  %v8 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.5524546
1)) %v9999;
  %v9 := pair:%v7 %v8;
  %v10 := op:xor 
w: โ„•
w %v9;
  %v11 := pair:%v5 %v4;
  %v12 := op:or 
w: โ„•
w %v11
  dsl_ret %v12
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair Context.Var.last
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Bโœ, Aโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 11
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜             (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 8
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 6
                          (TSSA.pair Context.Var.last
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ))
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair Context.Var.last
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Bโœ, Aโœ: โ„•

(do
    let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ (-1))
    pure (Bitvec.or fst (Bitvec.xor (Bitvec.or x x_1) x_2))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let x โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.or fst (Bitvec.xor x x_1))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair Context.Var.last
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Bโœ, Aโœ: โ„•

some
    (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ)
      (Bitvec.xor (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Bitvec.ofInt' wโœ (-1)))) =   some (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Bโœ) (Bitvec.ofInt' wโœ (-1))))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair Context.Var.last
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2285
-- precondition: true
/-
  %o = xor %A, %B
  %op1 = xor %o, -1
  %r = or %A, %op1

=>
  %not = xor %B, -1
  %o = xor %A, %B
  %op1 = xor %o, -1
  %r = or %A, %not

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
B: โ„•
B 
A: โ„•
A : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.5721130
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.5721882
1)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := pair:%v1 %v7;
  %v9 := op:or 
w: โ„•
w %v8
  dsl_ret %v9
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.5721130
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.5727106
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v6 := pair:%v5 %v1;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.5725216
1)) %v9999;
  %v9 := pair:%v7 %v8;
  %v10 := op:xor 
w: โ„•
w %v9;
  %v11 := pair:%v5 %v4;
  %v12 := op:or 
w: โ„•
w %v11
  dsl_ret %v12
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair Context.Var.last
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Bโœ, Aโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 11
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜             (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 8
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 6
                          (TSSA.pair Context.Var.last
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ))
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair Context.Var.last
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Bโœ, Aโœ: โ„•

(do
    let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ (-1))
    pure (Bitvec.or fst (Bitvec.xor (Bitvec.xor x x_1) x_2))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let x โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.or fst (Bitvec.xor x x_1))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair Context.Var.last
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Bโœ, Aโœ: โ„•

some
    (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ)
      (Bitvec.xor (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Bitvec.ofInt' wโœ (-1)))) =   some (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Bโœ) (Bitvec.ofInt' wโœ (-1))))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (B A : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.pair Context.Var.last
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2297
-- precondition: true
/-
  %op0 = and %A, %B
  %na = xor %A, -1
  %op1 = xor %na, %B
  %r = or %op0, %op1

=>
  %na = xor %A, -1
  %op0 = and %A, %B
  %op1 = xor %na, %B
  %r = xor %na, %B

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
B: โ„•
B 
A: โ„•
A 
B: โ„•
B : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.5922200
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.5923346
1)) %v9999;
  %v6 := pair:%v1 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := pair:%v7 %v2;
  %v9 := op:xor 
w: โ„•
w %v8;
  %v10 := pair:%v4 %v9;
  %v11 := op:or 
w: โ„•
w %v10
  dsl_ret %v11
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.5922200
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.5927521
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
B: โ„•
B)) %v9999;
  %v6 := pair:%v1 %v5;
  %v7 := op:and 
w: โ„•
w %v6;
  %v8 := pair:%v4 %v5;
  %v9 := op:xor 
w: โ„•
w %v8;
  %v10 := pair:%v4 %v5;
  %v11 := op:xor 
w: โ„•
w %v10
  dsl_ret %v11
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 8
                    (TSSA.pair Context.Var.last
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 10
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 8
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 6
                        (TSSA.pair
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Bโœ))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_4 โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
    pure (Bitvec.or (Bitvec.and x x_1) (Bitvec.xor (Bitvec.xor x_2 x_3) x_4))) =   do
  let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘Bโœ)
  pure (Bitvec.xor (Bitvec.xor x x_1) snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, Bโœยน, Aโœ, Bโœ: โ„•

some
    (Bitvec.or (Bitvec.and (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘Bโœ))
      (Bitvec.xor (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘Bโœ))) =   some (Bitvec.xor (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘Bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (A B : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 11 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘B))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2367
-- precondition: true
/-
  %op0 = or %A, C1
  %r = or %op0, %op1

=>
  %i = or %A, %op1
  %op0 = or %A, C1
  %r = or %i, C1

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
A: โ„•
A 
C1: โ„•
C1 
op1: โ„•
op1 
A: โ„•
A 
op1: โ„•
op1 
C1: โ„•
C1 : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.6149719
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
C1: โ„•
C1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:or 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
op1: โ„•
op1)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:or 
w: โ„•
w %v6
  dsl_ret %v7
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.6149719
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
A: โ„•
A)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
op1: โ„•
op1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:or 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
C1: โ„•
C1)) %v9999;
  %v6 := pair:%v1 %v5;
  %v7 := op:or 
w: โ„•
w %v6;
  %v8 := pair:%v4 %v5;
  %v9 := op:or 
w: โ„•
w %v8
  dsl_ret %v9
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A op1 C1 : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1))
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                            (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, C1โœยน, op1โœยน, Aโœ, op1โœ, C1โœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 5
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘op1โœ))
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘C1โœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                  (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 6
                    (TSSA.pair
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                      Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘C1โœ))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘op1โœ)) (Context.Var.prev Context.Var.last)
                              TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘Aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A op1 C1 : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1))
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                            (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, C1โœยน, op1โœยน, Aโœ, op1โœ, C1โœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘C1โœ)
    let snd โ† some (Bitvec.ofInt' wโœ โ†‘op1โœ)
    pure (Bitvec.or (Bitvec.or x x_1) snd)) =   do
  let x โ† some (Bitvec.ofInt' wโœ โ†‘Aโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘op1โœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘C1โœ)
  pure (Bitvec.or (Bitvec.or x x_1) snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A op1 C1 : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1))
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                            (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, Aโœยน, C1โœยน, op1โœยน, Aโœ, op1โœ, C1โœ: โ„•

some (Bitvec.or (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘C1โœ)) (Bitvec.ofInt' wโœ โ†‘op1โœ)) =   some (Bitvec.or (Bitvec.or (Bitvec.ofInt' wโœ โ†‘Aโœ) (Bitvec.ofInt' wโœ โ†‘op1โœ)) (Bitvec.ofInt' wโœ โ†‘C1โœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (A op1 C1 : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1))
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                            (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘C1))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘A)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2416
-- precondition: true
/-
  %x = xor %nx, -1
  %op0 = and %x, %y
  %r = xor %op0, -1

=>
  %ny = xor %y, -1
  %x = xor %nx, -1
  %op0 = and %x, %y
  %r = or %nx, %ny

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
nx: โ„•
nx 
y: โ„•
y 
y: โ„•
y 
nx: โ„•
nx : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.6311115
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
nx: โ„•
nx)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6313385
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
y: โ„•
y)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:and 
w: โ„•
w %v6;
  %v8 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6311475
1)) %v9999;
  %v9 := pair:%v7 %v8;
  %v10 := op:xor 
w: โ„•
w %v9
  dsl_ret %v10
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.6311115
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
y: โ„•
y)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6316916
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
nx: โ„•
nx)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6315413
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v8 %v1;
  %v10 := op:and 
w: โ„•
w %v9;
  %v11 := pair:%v5 %v4;
  %v12 := op:or 
w: โ„•
w %v11
  dsl_ret %v12
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (y nx : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, nxโœยน, yโœยน, yโœ, nxโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 8
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘yโœ))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘nxโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 11
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜             (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 9
                    (TSSA.pair Context.Var.last
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                 (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 6
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘nxโœ))
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘yโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (y nx : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, nxโœยน, yโœยน, yโœ, nxโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘nxโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘yโœ)
    let snd โ† some (Bitvec.ofInt' wโœ (-1))
    pure (Bitvec.xor (Bitvec.and (Bitvec.xor x x_1) x_2) snd)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘nxโœ)
  let x โ† some (Bitvec.ofInt' wโœ โ†‘yโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.or fst (Bitvec.xor x x_1))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (y nx : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, nxโœยน, yโœยน, yโœ, nxโœ: โ„•

some
    (Bitvec.xor (Bitvec.and (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘nxโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘yโœ))
      (Bitvec.ofInt' wโœ (-1))) =   some (Bitvec.or (Bitvec.ofInt' wโœ โ†‘nxโœ) (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘yโœ) (Bitvec.ofInt' wโœ (-1))))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (y nx : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2417
-- precondition: true
/-
  %x = xor %nx, -1
  %op0 = or %x, %y
  %r = xor %op0, -1

=>
  %ny = xor %y, -1
  %x = xor %nx, -1
  %op0 = or %x, %y
  %r = and %nx, %ny

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
nx: โ„•
nx 
y: โ„•
y 
y: โ„•
y 
nx: โ„•
nx : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.6512261
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
nx: โ„•
nx)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6514531
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
y: โ„•
y)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:or 
w: โ„•
w %v6;
  %v8 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6512621
1)) %v9999;
  %v9 := pair:%v7 %v8;
  %v10 := op:xor 
w: โ„•
w %v9
  dsl_ret %v10
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.6512261
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
y: โ„•
y)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6518062
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
nx: โ„•
nx)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6516559
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v8 %v1;
  %v10 := op:or 
w: โ„•
w %v9;
  %v11 := pair:%v5 %v4;
  %v12 := op:and 
w: โ„•
w %v11
  dsl_ret %v12
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (y nx : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, nxโœยน, yโœยน, yโœ, nxโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 8
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘yโœ))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                          TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘nxโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 11
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜             (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 9
                    (TSSA.pair Context.Var.last
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                 (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 6
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘nxโœ))
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘yโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (y nx : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, nxโœยน, yโœยน, yโœ, nxโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘nxโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘yโœ)
    let snd โ† some (Bitvec.ofInt' wโœ (-1))
    pure (Bitvec.xor (Bitvec.or (Bitvec.xor x x_1) x_2) snd)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘nxโœ)
  let x โ† some (Bitvec.ofInt' wโœ โ†‘yโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.and fst (Bitvec.xor x x_1))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (y nx : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, nxโœยน, yโœยน, yโœ, nxโœ: โ„•

some
    (Bitvec.xor (Bitvec.or (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘nxโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘yโœ))
      (Bitvec.ofInt' wโœ (-1))) =   some (Bitvec.and (Bitvec.ofInt' wโœ โ†‘nxโœ) (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘yโœ) (Bitvec.ofInt' wโœ (-1))))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (y nx : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 9 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘nx))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2429
-- precondition: true
/-
  %op0 = and %x, %y
  %r = xor %op0, -1

=>
  %nx = xor %x, -1
  %ny = xor %y, -1
  %op0 = and %x, %y
  %r = or %nx, %ny

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
x: โ„•
x 
y: โ„•
y 
x: โ„•
x 
y: โ„•
y : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.6713149
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
x: โ„•
x)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
y: โ„•
y)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6713509
1)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:xor 
w: โ„•
w %v6
  dsl_ret %v7
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.6713149
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
x: โ„•
x)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6718745
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
y: โ„•
y)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6717242
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v1 %v5;
  %v10 := op:and 
w: โ„•
w %v9;
  %v11 := pair:%v4 %v8;
  %v12 := op:or 
w: โ„•
w %v11
  dsl_ret %v12
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, xโœยน, yโœยน, xโœ, yโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 5
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘yโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘xโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 11
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                  (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜             (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 9
                    (TSSA.pair
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                 (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 6
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘yโœ))
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘xโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, xโœยน, yโœยน, xโœ, yโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘xโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘yโœ)
    let snd โ† some (Bitvec.ofInt' wโœ (-1))
    pure (Bitvec.xor (Bitvec.and x x_1) snd)) =   do
  let x โ† some (Bitvec.ofInt' wโœ โ†‘xโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
  let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘yโœ)
  let x_3 โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.or (Bitvec.xor x x_1) (Bitvec.xor x_2 x_3))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, xโœยน, yโœยน, xโœ, yโœ: โ„•

some (Bitvec.xor (Bitvec.and (Bitvec.ofInt' wโœ โ†‘xโœ) (Bitvec.ofInt' wโœ โ†‘yโœ)) (Bitvec.ofInt' wโœ (-1))) =   some
    (Bitvec.or (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘xโœ) (Bitvec.ofInt' wโœ (-1)))
      (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘yโœ) (Bitvec.ofInt' wโœ (-1))))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2430
-- precondition: true
/-
  %op0 = or %x, %y
  %r = xor %op0, -1

=>
  %nx = xor %x, -1
  %ny = xor %y, -1
  %op0 = or %x, %y
  %r = and %nx, %ny

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
x: โ„•
x 
y: โ„•
y 
x: โ„•
x 
y: โ„•
y : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.6910649
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
x: โ„•
x)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
y: โ„•
y)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:or 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6911009
1)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:xor 
w: โ„•
w %v6
  dsl_ret %v7
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.6910649
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
x: โ„•
x)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6916245
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
y: โ„•
y)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.6914742
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v1 %v5;
  %v10 := op:or 
w: โ„•
w %v9;
  %v11 := pair:%v4 %v8;
  %v12 := op:and 
w: โ„•
w %v11
  dsl_ret %v12
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, xโœยน, yโœยน, xโœ, yโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 5
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 2
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘yโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘xโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 11
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                  (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜             (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 9
                    (TSSA.pair
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                 (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 6
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘yโœ))
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘xโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, xโœยน, yโœยน, xโœ, yโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘xโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘yโœ)
    let snd โ† some (Bitvec.ofInt' wโœ (-1))
    pure (Bitvec.xor (Bitvec.or x x_1) snd)) =   do
  let x โ† some (Bitvec.ofInt' wโœ โ†‘xโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
  let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘yโœ)
  let x_3 โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.and (Bitvec.xor x x_1) (Bitvec.xor x_2 x_3))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, xโœยน, yโœยน, xโœ, yโœ: โ„•

some (Bitvec.xor (Bitvec.or (Bitvec.ofInt' wโœ โ†‘xโœ) (Bitvec.ofInt' wโœ โ†‘yโœ)) (Bitvec.ofInt' wโœ (-1))) =   some
    (Bitvec.and (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘xโœ) (Bitvec.ofInt' wโœ (-1)))
      (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘yโœ) (Bitvec.ofInt' wโœ (-1))))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (x y : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 5
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 2
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y)) (Context.Var.prev Context.Var.last)
                                  TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 1
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                         (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6
                                  (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘y))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘x)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2581  (B|A)^B -> A & ~B
-- precondition: true
/-
  %op0 = or %a, %op1
  %r = xor %op0, %op1

=>
  %nop1 = xor %op1, -1
  %op0 = or %a, %op1
  %r = and %a, %nop1

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
op1: โ„•
op1 
op1: โ„•
op1 
a: โ„•
a : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.7106903
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
op1: โ„•
op1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:or 
w: โ„•
w %v3;
  %v5 := pair:%v4 %v2;
  %v6 := op:xor 
w: โ„•
w %v5
  dsl_ret %v6
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.7106903
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
op1: โ„•
op1)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.7109899
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v6 := pair:%v5 %v1;
  %v7 := op:or 
w: โ„•
w %v6;
  %v8 := pair:%v5 %v4;
  %v9 := op:and 
w: โ„•
w %v8
  dsl_ret %v9
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (op1 a : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) (Context.Var.prev Context.Var.last)
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, op1โœยน, op1โœ, aโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 5 (TSSA.pair Context.Var.last (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 2
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘op1โœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 6
                    (TSSA.pair Context.Var.last
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                              TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘op1โœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (op1 a : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) (Context.Var.prev Context.Var.last)
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, op1โœยน, op1โœ, aโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘op1โœ)
    let snd โ† some (Bitvec.ofInt' wโœ โ†‘op1โœ)
    pure (Bitvec.xor (Bitvec.or x x_1) snd)) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let x โ† some (Bitvec.ofInt' wโœ โ†‘op1โœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.and fst (Bitvec.xor x x_1))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (op1 a : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) (Context.Var.prev Context.Var.last)
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, op1โœยน, op1โœ, aโœ: โ„•

some (Bitvec.xor (Bitvec.or (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘op1โœ)) (Bitvec.ofInt' wโœ โ†‘op1โœ)) =   some (Bitvec.and (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘op1โœ) (Bitvec.ofInt' wโœ (-1))))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (op1 a : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) (Context.Var.prev Context.Var.last)
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last))
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair Context.Var.last
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2587  (B&A)^A -> ~B & A
-- precondition: true
/-
  %op0 = and %a, %op1
  %r = xor %op0, %op1

=>
  %na = xor %a, -1
  %op0 = and %a, %op1
  %r = and %na, %op1

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
op1: โ„•
op1 
a: โ„•
a 
op1: โ„•
op1 : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.7268446
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
op1: โ„•
op1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v4 %v2;
  %v6 := op:xor 
w: โ„•
w %v5
  dsl_ret %v6
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.7268446
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.7271442
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
op1: โ„•
op1)) %v9999;
  %v6 := pair:%v1 %v5;
  %v7 := op:and 
w: โ„•
w %v6;
  %v8 := pair:%v4 %v5;
  %v9 := op:and 
w: โ„•
w %v8
  dsl_ret %v9
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a op1 : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) (Context.Var.prev Context.Var.last)
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, op1โœยน, aโœ, op1โœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 5 (TSSA.pair Context.Var.last (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 2
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘op1โœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                  (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 6
                    (TSSA.pair
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                      Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘op1โœ))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                              TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a op1 : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) (Context.Var.prev Context.Var.last)
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, op1โœยน, aโœ, op1โœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘op1โœ)
    let snd โ† some (Bitvec.ofInt' wโœ โ†‘op1โœ)
    pure (Bitvec.xor (Bitvec.and x x_1) snd)) =   do
  let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘op1โœ)
  pure (Bitvec.and (Bitvec.xor x x_1) snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a op1 : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) (Context.Var.prev Context.Var.last)
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, op1โœยน, aโœ, op1โœ: โ„•

some (Bitvec.xor (Bitvec.and (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘op1โœ)) (Bitvec.ofInt' wโœ โ†‘op1โœ)) =   some (Bitvec.and (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘op1โœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a op1 : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 5
                        (TSSA.pair Context.Var.last (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 2
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1)) (Context.Var.prev Context.Var.last)
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 8
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                     (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 6
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 5
                              (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘op1))
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 2
                                    (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                      TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 1
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2595
-- precondition: true
/-
  %op0 = and %a, %b
  %op1 = or %a, %b
  %r = xor %op0, %op1

=>
  %op0 = and %a, %b
  %op1 = or %a, %b
  %r = xor %a, %b

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
b: โ„•
b 
a: โ„•
a 
b: โ„•
b : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.7430252
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:or 
w: โ„•
w %v5;
  %v7 := pair:%v4 %v6;
  %v8 := op:xor 
w: โ„•
w %v7
  dsl_ret %v8
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.7430252
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:or 
w: โ„•
w %v5;
  %v7 := pair:%v1 %v2;
  %v8 := op:xor 
w: โ„•
w %v7
  dsl_ret %v8
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    pure (Bitvec.xor (Bitvec.and x x_1) (Bitvec.or x_2 x_3))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
  pure (Bitvec.xor fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

some
    (Bitvec.xor (Bitvec.and (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))
      (Bitvec.or (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))) =   some (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2607
-- precondition: true
/-
  %na = xor %a, -1
  %nb = xor %b, -1
  %op0 = or %a, %nb
  %op1 = or %na, %b
  %r = xor %op0, %op1

=>
  %na = xor %a, -1
  %nb = xor %b, -1
  %op0 = or %a, %nb
  %op1 = or %na, %b
  %r = xor %a, %b

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
b: โ„•
b 
a: โ„•
a 
b: โ„•
b : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.7592120
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.7595196
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.7593662
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v1 %v8;
  %v10 := op:or 
w: โ„•
w %v9;
  %v11 := pair:%v4 %v5;
  %v12 := op:or 
w: โ„•
w %v11;
  %v13 := pair:%v10 %v12;
  %v14 := op:xor 
w: โ„•
w %v13
  dsl_ret %v14
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.7592120
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.7599109
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.7597606
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v1 %v8;
  %v10 := op:or 
w: โ„•
w %v9;
  %v11 := pair:%v4 %v5;
  %v12 := op:or 
w: โ„•
w %v11;
  %v13 := pair:%v1 %v5;
  %v14 := op:xor 
w: โ„•
w %v13
  dsl_ret %v14
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 13 (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 11
                    (TSSA.pair
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                 (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 13
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))))
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜             (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 11
                    (TSSA.pair
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                 (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_4 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_5 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    pure (Bitvec.xor (Bitvec.or x (Bitvec.xor x_1 x_2)) (Bitvec.or (Bitvec.xor x_3 x_4) x_5))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
  pure (Bitvec.xor fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

some
    (Bitvec.xor (Bitvec.or (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘bโœ) (Bitvec.ofInt' wโœ (-1))))
      (Bitvec.or (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘bโœ))) =   some (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2617
-- precondition: true
/-
  %na = xor %a, -1
  %nb = xor %b, -1
  %op0 = and %a, %nb
  %op1 = and %na, %b
  %r = xor %op0, %op1

=>
  %na = xor %a, -1
  %nb = xor %b, -1
  %op0 = and %a, %nb
  %op1 = and %na, %b
  %r = xor %a, %b

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
b: โ„•
b 
a: โ„•
a 
b: โ„•
b : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.7835763
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.7838839
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.7837305
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v1 %v8;
  %v10 := op:and 
w: โ„•
w %v9;
  %v11 := pair:%v4 %v5;
  %v12 := op:and 
w: โ„•
w %v11;
  %v13 := pair:%v10 %v12;
  %v14 := op:xor 
w: โ„•
w %v13
  dsl_ret %v14
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.7835763
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.7842752
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v6 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.7841249
1)) %v9999;
  %v7 := pair:%v5 %v6;
  %v8 := op:xor 
w: โ„•
w %v7;
  %v9 := pair:%v1 %v8;
  %v10 := op:and 
w: โ„•
w %v9;
  %v11 := pair:%v4 %v5;
  %v12 := op:and 
w: โ„•
w %v11;
  %v13 := pair:%v1 %v5;
  %v14 := op:xor 
w: โ„•
w %v13
  dsl_ret %v14
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 13 (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 11
                    (TSSA.pair
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                 (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 13
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))))
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜             (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 11
                    (TSSA.pair
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                 (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_4 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_5 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    pure (Bitvec.xor (Bitvec.and x (Bitvec.xor x_1 x_2)) (Bitvec.and (Bitvec.xor x_3 x_4) x_5))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
  pure (Bitvec.xor fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

some
    (Bitvec.xor (Bitvec.and (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘bโœ) (Bitvec.ofInt' wโœ (-1))))
      (Bitvec.and (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘bโœ))) =   some (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 13
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))) โˆ˜                     (fun prev => TSSA.assign prev 12 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 11
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                         (fun prev => TSSA.assign prev 10 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 9
                                (TSSA.pair
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                  Context.Var.last)) โˆ˜                             (fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 7 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 6
                                      (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 5
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                          TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 3
                                            (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 2
                                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 1
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                             (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2627
-- precondition: true
/-
  %op0 = xor %a, %c
  %op1 = or %a, %b
  %r = xor %op0, %op1

=>
  %na = xor %a, -1
  %and = and %na, %b
  %op0 = xor %a, %c
  %op1 = or %a, %b
  %r = xor %and, %c

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
c: โ„•
c 
b: โ„•
b 
a: โ„•
a 
b: โ„•
b 
c: โ„•
c : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.8078140
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
c: โ„•
c)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v6 := pair:%v1 %v5;
  %v7 := op:or 
w: โ„•
w %v6;
  %v8 := pair:%v4 %v7;
  %v9 := op:xor 
w: โ„•
w %v8
  dsl_ret %v9
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.8078140
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.8083600
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v6 := pair:%v4 %v5;
  %v7 := op:and 
w: โ„•
w %v6;
  %v8 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
c: โ„•
c)) %v9999;
  %v9 := pair:%v1 %v8;
  %v10 := op:xor 
w: โ„•
w %v9;
  %v11 := pair:%v1 %v5;
  %v12 := op:or 
w: โ„•
w %v11;
  %v13 := pair:%v7 %v8;
  %v14 := op:xor 
w: โ„•
w %v13
  dsl_ret %v14
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (a b c : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                            Context.Var.last)) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘c)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 13
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 11
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                           (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 9
                                  (TSSA.pair
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 8
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘c))
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 6
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 5
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 3
                                              (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 2
                                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                  (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 1
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last
                                                    TSSA.rgn0)) โˆ˜                                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœยฒ: Context BaseType

e: EnvC cโœยฒ

wโœ, aโœยน, cโœยน, bโœยน, aโœ, bโœ, cโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 8
                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 6
                    (TSSA.pair
                      (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                      Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 5
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ))
                        (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 2
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘cโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 13
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜             (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 11
                    (TSSA.pair
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                 (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 9
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘cโœ))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (a b c : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                            Context.Var.last)) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘c)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 13
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 11
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                           (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 9
                                  (TSSA.pair
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 8
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘c))
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 6
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 5
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 3
                                              (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 2
                                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                  (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 1
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last
                                                    TSSA.rgn0)) โˆ˜                                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœยฒ: Context BaseType

e: EnvC cโœยฒ

wโœ, aโœยน, cโœยน, bโœยน, aโœ, bโœ, cโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘cโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    pure (Bitvec.xor (Bitvec.xor x x_1) (Bitvec.or x_2 x_3))) =   do
  let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ (-1))
  let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘cโœ)
  pure (Bitvec.xor (Bitvec.and (Bitvec.xor x x_1) x_2) snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (a b c : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                            Context.Var.last)) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘c)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 13
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 11
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                           (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 9
                                  (TSSA.pair
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 8
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘c))
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 6
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 5
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 3
                                              (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 2
                                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                  (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 1
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last
                                                    TSSA.rgn0)) โˆ˜                                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
cโœยฒ: Context BaseType

e: EnvC cโœยฒ

wโœ, aโœยน, cโœยน, bโœยน, aโœ, bโœ, cโœ: โ„•

some
    (Bitvec.xor (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘cโœ))
      (Bitvec.or (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))) =   some
    (Bitvec.xor (Bitvec.and (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ (-1))) (Bitvec.ofInt' wโœ โ†‘bโœ))
      (Bitvec.ofInt' wโœ โ†‘cโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โ„• โ†’
        โˆ€ (a b c : โ„•),
          TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 9 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 8
                          (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                            Context.Var.last)) โˆ˜                       (fun prev => TSSA.assign prev 7 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 6
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 5
                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 2
                                      (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘c)) (Context.Var.prev Context.Var.last)
                                        TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 1
                                        (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                     (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e =             TSSA.eval
              (TSSA.ret
                (((fun prev => TSSA.assign prev 14 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 13
                          (TSSA.pair
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                       (fun prev => TSSA.assign prev 12 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 11
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))) โˆ˜                           (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 9
                                  (TSSA.pair
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                    Context.Var.last)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 8
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘c))
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 6
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 5
                                          (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 3
                                              (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 2
                                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                                  (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 1
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last
                                                    TSSA.rgn0)) โˆ˜                                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                  TSSA.nop)
                Context.Var.last)
              e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2647
-- precondition: true
/-
  %op0 = and %a, %b
  %op1 = xor %a, %b
  %r = xor %op0, %op1

=>
  %op0 = and %a, %b
  %op1 = xor %a, %b
  %r = or %a, %b

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
a: โ„•
a 
b: โ„•
b 
a: โ„•
a 
b: โ„•
b : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.8313380
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:xor 
w: โ„•
w %v5;
  %v7 := pair:%v4 %v6;
  %v8 := op:xor 
w: โ„•
w %v7
  dsl_ret %v8
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.8313380
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := pair:%v1 %v2;
  %v6 := op:xor 
w: โ„•
w %v5;
  %v7 := pair:%v1 %v2;
  %v8 := op:or 
w: โ„•
w %v7
  dsl_ret %v8
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7 (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 7
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                  (Context.Var.prev (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜             (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 5
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 2
                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 1 (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    pure (Bitvec.xor (Bitvec.and x x_1) (Bitvec.xor x_2 x_3))) =   do
  let fst โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let snd โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
  pure (Bitvec.or fst snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, aโœยน, bโœยน, aโœ, bโœ: โ„•

some
    (Bitvec.xor (Bitvec.and (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))
      (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))) =   some (Bitvec.or (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair (Context.Var.prev (Context.Var.prev Context.Var.last)) Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 8 (TSSA.op (Op.or w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 7
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))
                          (Context.Var.prev
                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              (Context.Var.prev (Context.Var.prev Context.Var.last)))) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™


-- Name:AndOrXor:2658
-- precondition: true
/-
  %nb = xor %b, -1
  %op0 = and %a, %nb
  %na = xor %a, -1
  %r = xor %op0, %na

=>
  %and = and %a, %b
  %nb = xor %b, -1
  %op0 = and %a, %nb
  %na = xor %a, -1
  %r = xor %and, -1

-/
open SSA EDSL in

Warning: declaration uses 'sorry'
 : forall (
w: โ„•
w : 
Nat: Type
Nat) (
b: โ„•
b 
a: โ„•
a 
a: โ„•
a 
b: โ„•
b : 
Nat: Type
Nat),
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.8474809
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.8477458
1)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:xor 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v6 := pair:%v5 %v4;
  %v7 := op:and 
w: โ„•
w %v6;
  %v8 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.8475553
1)) %v9999;
  %v9 := pair:%v5 %v8;
  %v10 := op:xor 
w: โ„•
w %v9;
  %v11 := pair:%v7 %v10;
  %v12 := op:xor 
w: โ„•
w %v11
  dsl_ret %v12
  ]  = 
  
TSSA.eval: {Op ฮฒ : Type} โ†’
  [inst : Goedel ฮฒ] โ†’
    [TUS : TypedUserSemantics Op ฮฒ] โ†’ {ฮ“ : Context ฮฒ} โ†’ {i : TSSAIndex ฮฒ} โ†’ TSSA Op ฮ“ i โ†’ EnvC ฮ“ โ†’ TSSAIndex.eval i
TSSA.eval
  (Op := 
Op: Type
Op) (e := 
e: ?m.8474809
e)
  (i := 
TSSAIndex.TERMINATOR: {ฮฒ : Type} โ†’ SSA.UserType ฮฒ โ†’ TSSAIndex ฮฒ
TSSAIndex.TERMINATOR (
UserType.base: {ฮฒ : Type} โ†’ ฮฒ โ†’ SSA.UserType ฮฒ
UserType.base (
BaseType.bitvec: โ„• โ†’ BaseType
BaseType.bitvec 
w: โ„•
w)))
  [dsl_bb|
  ^bb
  %v9999 := unit: ;
  %v1 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
a: โ„•
a)) %v9999;
  %v2 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (
b: โ„•
b)) %v9999;
  %v3 := pair:%v1 %v2;
  %v4 := op:and 
w: โ„•
w %v3;
  %v5 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.8480349
1)) %v9999;
  %v6 := pair:%v2 %v5;
  %v7 := op:xor 
w: โ„•
w %v6;
  %v8 := pair:%v1 %v7;
  %v9 := op:and 
w: โ„•
w %v8;
  %v10 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.8479431
1)) %v9999;
  %v11 := pair:%v1 %v10;
  %v12 := op:xor 
w: โ„•
w %v11;
  %v13 := op:const (
Bitvec.ofInt': (n : โ„•) โ†’ โ„ค โ†’ Bitvec n
Bitvec.ofInt' 
w: โ„•
w (-
1: ?m.8478833
1)) %v9999;
  %v14 := pair:%v4 %v13;
  %v15 := op:xor 
w: โ„•
w %v14
  dsl_ret %v15
  ]
  := 
Goals accomplished! ๐Ÿ™
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 15 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 14
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 13
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 11
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 10
                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 8
                                    (TSSA.pair
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                      Context.Var.last)) โˆ˜                                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 6
                                        (TSSA.pair
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                          Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 5
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 3
                                              (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 2
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                                  (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 1
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last
                                                    TSSA.rgn0)) โˆ˜                                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, bโœยน, aโœยน, aโœ, bโœ: โ„•

TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 11
                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                  Context.Var.last)) โˆ˜             (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜               (fun prev =>
                  TSSA.assign prev 9
                    (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                      Context.Var.last)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 8
                      (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                        TSSA.rgn0)) โˆ˜                   (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                       (fun prev =>
                          TSSA.assign prev 5
                            (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ))
                              (Context.Var.prev
                                (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                              TSSA.rgn0)) โˆ˜                         (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 3 (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 2
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1))) (Context.Var.prev Context.Var.last)
                                    TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 1
                                    (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e =   TSSA.eval
    (TSSA.ret
      (((fun prev => TSSA.assign prev 15 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜           (fun prev =>
              TSSA.assign prev 14
                (TSSA.pair
                  (Context.Var.prev
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                  Context.Var.last)) โˆ˜             (fun prev =>
                TSSA.assign prev 13
                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                    (Context.Var.prev
                      (Context.Var.prev
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))
                    TSSA.rgn0)) โˆ˜               (fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                 (fun prev =>
                    TSSA.assign prev 11
                      (TSSA.pair
                        (Context.Var.prev
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                        Context.Var.last)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 10
                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                          TSSA.rgn0)) โˆ˜                     (fun prev => TSSA.assign prev 9 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 8
                            (TSSA.pair
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                              Context.Var.last)) โˆ˜                         (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 6
                                (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                  Context.Var.last)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 5
                                  (TSSA.op (Op.const (Bitvec.ofInt' wโœ (-1)))
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                    TSSA.rgn0)) โˆ˜                               (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and wโœ) Context.Var.last TSSA.rgn0)) โˆ˜                                 (fun prev =>
                                    TSSA.assign prev 3
                                      (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 2
                                        (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘bโœ)) (Context.Var.prev Context.Var.last)
                                          TSSA.rgn0)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 1
                                          (TSSA.op (Op.const (Bitvec.ofInt' wโœ โ†‘aโœ)) Context.Var.last TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
        TSSA.nop)
      Context.Var.last)
    e
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 15 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 14
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 13
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 11
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 10
                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 8
                                    (TSSA.pair
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                      Context.Var.last)) โˆ˜                                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 6
                                        (TSSA.pair
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                          Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 5
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 3
                                              (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 2
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                                  (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 1
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last
                                                    TSSA.rgn0)) โˆ˜                                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, bโœยน, aโœยน, aโœ, bโœ: โ„•

(do
    let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
    let x_2 โ† some (Bitvec.ofInt' wโœ (-1))
    let x_3 โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
    let x_4 โ† some (Bitvec.ofInt' wโœ (-1))
    pure (Bitvec.xor (Bitvec.and x (Bitvec.xor x_1 x_2)) (Bitvec.xor x_3 x_4))) =   do
  let x โ† some (Bitvec.ofInt' wโœ โ†‘aโœ)
  let x_1 โ† some (Bitvec.ofInt' wโœ โ†‘bโœ)
  let snd โ† some (Bitvec.ofInt' wโœ (-1))
  pure (Bitvec.xor (Bitvec.and x x_1) snd)
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 15 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 14
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 13
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 11
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 10
                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 8
                                    (TSSA.pair
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                      Context.Var.last)) โˆ˜                                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 6
                                        (TSSA.pair
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                          Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 5
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 3
                                              (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 2
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                                  (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 1
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last
                                                    TSSA.rgn0)) โˆ˜                                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
cโœ: Context BaseType

e: EnvC cโœ

wโœ, bโœยน, aโœยน, aโœ, bโœ: โ„•

some
    (Bitvec.xor (Bitvec.and (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘bโœ) (Bitvec.ofInt' wโœ (-1))))
      (Bitvec.xor (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ (-1)))) =   some (Bitvec.xor (Bitvec.and (Bitvec.ofInt' wโœ โ†‘aโœ) (Bitvec.ofInt' wโœ โ†‘bโœ)) (Bitvec.ofInt' wโœ (-1)))
cโœ: Context BaseType

e: EnvC cโœ

โˆ€ (w : โ„•),
  โ„• โ†’
    โ„• โ†’
      โˆ€ (a b : โ„•),
        TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 11
                        (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                          Context.Var.last)) โˆ˜                     (fun prev => TSSA.assign prev 10 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                       (fun prev =>
                          TSSA.assign prev 9
                            (TSSA.pair (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                              Context.Var.last)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 8
                              (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))
                                TSSA.rgn0)) โˆ˜                           (fun prev => TSSA.assign prev 7 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                             (fun prev =>
                                TSSA.assign prev 6 (TSSA.pair Context.Var.last (Context.Var.prev Context.Var.last))) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 5
                                    (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a))
                                      (Context.Var.prev
                                        (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                      TSSA.rgn0)) โˆ˜                                 (fun prev => TSSA.assign prev 4 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 3
                                        (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 2
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1))) (Context.Var.prev Context.Var.last)
                                            TSSA.rgn0)) โˆ˜                                       (fun prev =>
                                          TSSA.assign prev 1
                                            (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b)) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e =           TSSA.eval
            (TSSA.ret
              (((fun prev => TSSA.assign prev 15 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                   (fun prev =>
                      TSSA.assign prev 14
                        (TSSA.pair
                          (Context.Var.prev
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                          Context.Var.last)) โˆ˜                     (fun prev =>
                        TSSA.assign prev 13
                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                            (Context.Var.prev
                              (Context.Var.prev
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last))))))))))))
                            TSSA.rgn0)) โˆ˜                       (fun prev => TSSA.assign prev 12 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                         (fun prev =>
                            TSSA.assign prev 11
                              (TSSA.pair
                                (Context.Var.prev
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                Context.Var.last)) โˆ˜                           (fun prev =>
                              TSSA.assign prev 10
                                (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                  (Context.Var.prev
                                    (Context.Var.prev
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev
                                              (Context.Var.prev
                                                (Context.Var.prev (Context.Var.prev Context.Var.last)))))))))
                                  TSSA.rgn0)) โˆ˜                             (fun prev => TSSA.assign prev 9 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                               (fun prev =>
                                  TSSA.assign prev 8
                                    (TSSA.pair
                                      (Context.Var.prev
                                        (Context.Var.prev
                                          (Context.Var.prev
                                            (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))))
                                      Context.Var.last)) โˆ˜                                 (fun prev => TSSA.assign prev 7 (TSSA.op (Op.xor w) Context.Var.last TSSA.rgn0)) โˆ˜                                   (fun prev =>
                                      TSSA.assign prev 6
                                        (TSSA.pair
                                          (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last)))
                                          Context.Var.last)) โˆ˜                                     (fun prev =>
                                        TSSA.assign prev 5
                                          (TSSA.op (Op.const (Bitvec.ofInt' w (-1)))
                                            (Context.Var.prev
                                              (Context.Var.prev (Context.Var.prev (Context.Var.prev Context.Var.last))))
                                            TSSA.rgn0)) โˆ˜                                       (fun prev => TSSA.assign prev 4 (TSSA.op (Op.and w) Context.Var.last TSSA.rgn0)) โˆ˜                                         (fun prev =>
                                            TSSA.assign prev 3
                                              (TSSA.pair (Context.Var.prev Context.Var.last) Context.Var.last)) โˆ˜                                           (fun prev =>
                                              TSSA.assign prev 2
                                                (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘b))
                                                  (Context.Var.prev Context.Var.last) TSSA.rgn0)) โˆ˜                                             (fun prev =>
                                                TSSA.assign prev 1
                                                  (TSSA.op (Op.const (Bitvec.ofInt' w โ†‘a)) Context.Var.last
                                                    TSSA.rgn0)) โˆ˜                                               (fun prev => TSSA.assign prev 9999 TSSA.unit) โˆ˜ id)
                TSSA.nop)
              Context.Var.last)
            e
Goals accomplished! ๐Ÿ™